3. Aproximaciones para hallar las 2 raices mas cercanas a cero de 10sin(x+3) e^((x/2)+1) con exactitud de 10^(-15) con los métodos de bisección, falsa posición, Newton-Raphson y secante.

Método de bisección con puntos iniciales (-4,-2) y (0,1):



In [30]:

    
import math

def funcion(x):
    return (10*(math.sin(x+3))*(math.exp((x/2)+1)))

def biseccion(intA, intB, errorA, noMaxIter):
        if(funcion(intA)*funcion(intB)<0):
            print("---------------------------------------")
            print("X0: ",intA," X1: ",intB)
            print("No. max. iteraciones: ",noMaxIter)
            print("Error aceptable: ",errorA)
            noIter = 0
            errorTmp = 1
            intTmp = 0
            oldInt = intA
            while(noIter<noMaxIter and errorTmp>errorA and funcion(intTmp)!=0):
                intTmp = (intB+intA)/2
                if(funcion(intA)*funcion(intTmp)<0):
                    intB = intTmp
                else:
                    intA = intTmp
                noIter+=1
                errorTmp=abs(intTmp-oldInt)
                oldInt = intTmp
            print("---------------------------------------")
            print('La raíz es: ',intTmp)
            print('F(raiz) es:' ,funcion(intTmp))
            print('Error: ',errorTmp)
            print('No. de iteraciones realizadas: ',noIter)
            print("---------------------------------------")
        else:
            print('En el intervalo dado la función no presenta cambio de signo')
            print('No hay raices que encontrar')
            
biseccion(-4,-2,math.pow(10,-15),1000)
biseccion(0,1,math.pow(10,-15),1000)









    



---------------------------------------
X0:  -4  X1:  -2
No. max. iteraciones:  1000
Error aceptable:  1e-15
---------------------------------------
La raíz es:  -3.0
F(raiz) es: 0.0
Error:  1.0
No. de iteraciones realizadas:  1
---------------------------------------
---------------------------------------
X0:  0  X1:  1
No. max. iteraciones:  1000
Error aceptable:  1e-15
---------------------------------------
La raíz es:  0.141592653589794
F(raiz) es: -2.2341245248615222e-14
Error:  8.881784197001252e-16
No. de iteraciones realizadas:  50
---------------------------------------

Método de falsa posición con puntos iniciales (-4,-2) y (0,1):



In [31]:

    
import math

def funcion(x):
    return (10*(math.sin(x+3))*(math.exp((x/2)+1)))

def reglaFalsa(intA, intB, errorA, noMaxIter):
    if(funcion(intA)*funcion(intB)<0):
        print("---------------------------------------")
        print("X0: ",intA," X1: ",intB)
        print("No. max. iteraciones: ",noMaxIter)
        print("Error aceptable: ",errorA)
        noIter = 0
        errorTmp = 1
        intTmp = 0
        oldInt = intA
        try:
            while(noIter<noMaxIter and errorTmp>errorA and funcion(intTmp)!=0):
                intTmp = intA-((funcion(intA)*(intB-intA))/(funcion(intB)-funcion(intA)))
                if(funcion(intA)*funcion(intTmp)>0):
                    intB = intTmp
                else:
                    intA = intTmp
                noIter+=1
                errorTmp=abs((intTmp-oldInt)/intTmp)*100
                oldInt = intTmp
            print("---------------------------------------")
            print('La raíz es: ',intTmp)
            print('F(raiz) es:' ,funcion(intTmp))
            print('Error: ',errorTmp)
            print('No. de iteraciones realizadas: ',noIter)
            print("---------------------------------------")
        except ZeroDivisionError:
            print("---------------------------------------")
            print("¡División entre cero! : Posible raiz encontrada")    
            print('La raíz es: ',intTmp)
            print('F(raiz) es:' ,funcion(intTmp))
            print('Error: ',errorTmp)
            print('No. de iteraciones realizadas: ',noIter)
            print("---------------------------------------")
        
    else:
        print('En el intervalo dado la función no presenta cambio de signo')
        print('No hay raices que encontrar')
            
reglaFalsa(-4,-2,math.pow(10,-15),10000)
reglaFalsa(0,1,math.pow(10,-15),10000)









    



---------------------------------------
X0:  -4  X1:  -2
No. max. iteraciones:  10000
Error aceptable:  1e-15
---------------------------------------
La raíz es:  -3.0
F(raiz) es: 0.0
Error:  1.4802973661668752e-14
No. de iteraciones realizadas:  33
---------------------------------------
---------------------------------------
X0:  0  X1:  1
No. max. iteraciones:  10000
Error aceptable:  1e-15
---------------------------------------
¡División entre cero! : Posible raiz encontrada
La raíz es:  0.14159265358979323
F(raiz) es: 3.573154438935754e-15
Error:  9.801206104957724e-14
No. de iteraciones realizadas:  12
---------------------------------------

Método de Newton-Raphson con puntos iniciales -4 y 0:



In [32]:

    
import math

def funcion(x):
    return (10*(math.sin(x+3))*(math.exp((x/2)+1)))

def funcionDeriv(x):
    return (5*(math.exp((x/2)+1))*(math.sin(x+3)+(2*math.cos(x+3))))

def newtonRaphson(val, errorA, noMaxIter):
    noIter = 0
    errorTmp = 0
    print("---------------------------------------")
    print("Punto inicial: ",val)
    print("No. max. iteraciones: ",noMaxIter)
    print("Error aceptable: ",errorA)
    while(noIter<noMaxIter):
        valTmp = val-((funcion(val))/(funcionDeriv(val)))
        if abs(valTmp-val) < errorA:
            print("---------------------------------------")
            print('La raíz es: ',valTmp)
            print('F(raiz) es:' ,funcion(valTmp))
            print('Error: ',abs(valTmp-val))
            print('No. de iteraciones realizadas: ',noIter)
            print("---------------------------------------")
            break
        errorTmp = abs(valTmp-val)
        val = valTmp
        noIter+=1
    
newtonRaphson(-4, math.pow(10,-15),10000)
newtonRaphson(0, math.pow(10,-15),10000)









    



---------------------------------------
Punto inicial:  -4
No. max. iteraciones:  10000
Error aceptable:  1e-15
---------------------------------------
La raíz es:  3.283185307179587
F(raiz) es: 9.028347632386676e-14
Error:  4.440892098500626e-16
No. de iteraciones realizadas:  6
---------------------------------------
---------------------------------------
Punto inicial:  0
No. max. iteraciones:  10000
Error aceptable:  1e-15
---------------------------------------
La raíz es:  0.14159265358979342
F(raiz) es: -9.384045404839732e-15
Error:  1.1102230246251565e-16
No. de iteraciones realizadas:  4
---------------------------------------

Método de la secante con puntos iniciales (-4,-2) y (0,1):



In [33]:

    
import math

def funcion(x):
    return (10*(math.sin(x+3))*(math.exp((x/2)+1)))

def secante(primerVal, segundoVal, errorA, noMaxIter):
    noIter = 2
    errorTmp = 0
    valTmp = 0
    print("---------------------------------------")
    print("X0: ",primerVal," X1: ",segundoVal)
    print("No. max. iteraciones: ",noMaxIter)
    print("Error aceptable: ",errorA)
    try:
        while(noIter<noMaxIter):
            valTmp = segundoVal-((funcion(segundoVal)*(segundoVal-primerVal))/(funcion(segundoVal)-funcion(primerVal)))
            if abs(valTmp-segundoVal) < errorA:
                print("---------------------------------------")
                print('La raíz es: ',valTmp)
                print('F(raiz) es:' ,funcion(valTmp))
                print('Error: ',errorTmp)
                print('No. de iteraciones realizadas: ',noIter)
                print("---------------------------------------")
                break
            errorTmp = abs(valTmp-segundoVal)
            primerVal = segundoVal
            segundoVal = valTmp
            errorTmp=abs(segundoVal-primerVal)
            noIter+=1
    except ZeroDivisionError:
        print("---------------------------------------")
        print("¡División entre cero! : Posible raiz encontrada")    
        print('La raíz es: ',valTmp)
        print('F(raiz) es:' ,funcion(valTmp))
        print('Error: ',errorTmp)
        print('No. de iteraciones realizadas: ',noIter)
        print("---------------------------------------")
    
secante(-4,-2,math.pow(10,-15),10000)
secante(0,1,math.pow(10,-15),10000)









    



---------------------------------------
X0:  -4  X1:  -2
No. max. iteraciones:  10000
Error aceptable:  1e-15
---------------------------------------
La raíz es:  -3.0
F(raiz) es: 0.0
Error:  2.3591351094864876e-11
No. de iteraciones realizadas:  10
---------------------------------------
---------------------------------------
X0:  0  X1:  1
No. max. iteraciones:  10000
Error aceptable:  1e-15
---------------------------------------
La raíz es:  0.14159265358979314
F(raiz) es: 3.573154438935754e-15
Error:  1.303465946289606e-10
No. de iteraciones realizadas:  8
---------------------------------------

Tabla de comparación de resultados:

Método	Intervalo	Error aceptable	No. Max iteraciones	Raíz encontrada	Error obtenido	No. Iter realizadas
Bisección	-4,-2	10^(-15)	10000	-3.0	0	1
Bisección	0,1	10^(-15)	10000	0.14159265358979334	8.881784197001252e-16	50
Falsa posición	-4,-2	10^(-15)	10000	-3.0	1.4802973661668752e-14	33
Falsa posición	0,1	10^(-15)	10000	0.14159265358979323	9.801206104957724e-14	12
Newton-Raphson	-4	10^(-15)	10000	3.283185307179587	4.440892098500626e-16	6
Newton-Raphson	0	10^(-15)	10000	0.14159265358979342	1.1102230246251565e-16	4
Secante	-4,-2	10^(-15)	10000	-3.0	2.3591351094864876e-11	10
Secante	0,1	10^(-15)	10000	0.14159265358979314	1.303465946289606e-10	8

Análisis de resultados

El método de Newton-Raphson fue el más eficiente hallando la raíz entre 0 y 1 debido a que tardó menos iteraciones que los demás, con un error menor. Esto se debió a que la pendiente de la recta tangente en el punto 0 hace que convergiera muy rápido.
Debido al comportamiento que tiene la función en el punto -4, fue imposible hallar la raíz usando el método de Newton-Raphson. El valor de la pendiente de la recta tangente cerca de ese punto hace que este método diverga.
El método más demorado fue el de falsa posición. Debido a que este método aproxima la raíz trazando una linea que conecta los dos limites y tomando el punto en el que corta el eje x, se demora demasiado en acercarse a la raíz con precisión de 10^(-15).
Por la naturaleza del método de bisección (dividir el intervalo y actualizar el límite) fue el que más rápido encontro la primera raíz usando los intervalos -4 y -2.
En promedio, el método de la secante fue el método mas rápido hallando ambas raices en 10 y 8 iteraciones.

3. Aproximaciones para hallar las 2 raices mas cercanas a cero de 10*sin(x+3)* e^((x/2)+1) con exactitud de 10^(-15) con los métodos de bisección, falsa posición, Newton-Raphson y secante.

Método de bisección con puntos iniciales (-4,-2) y (0,1):

Método de falsa posición con puntos iniciales (-4,-2) y (0,1):

Método de Newton-Raphson con puntos iniciales -4 y 0:

Método de la secante con puntos iniciales (-4,-2) y (0,1):

Tabla de comparación de resultados:

Análisis de resultados

3. Aproximaciones para hallar las 2 raices mas cercanas a cero de 10sin(x+3) e^((x/2)+1) con exactitud de 10^(-15) con los métodos de bisección, falsa posición, Newton-Raphson y secante.